package Util;

import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;
import java.util.Random;
import java.io.Serializable;

/**
 * Esta clase se encarga de ordenar los objetos en una tabla hash
 * <PRE>ddxxdd</PRE>
 */
public final class SortedHashtable implements Serializable {
    
    private Hashtable hashSortedHashtable = new Hashtable();
    private Vector vectSortedHashtable = new Vector();
        
    /**
     * 
     * @return Devuelve un objeto de la clase VectorEnumerator que implementa el interface Enumeration y 
     * tiene que definir las dos funciones hasMoreElements y nextElement.
     * 
     * final class VectorEnumerator implements Enumeration {
     *    Vector vector;
     *    int count;
     *    VectorEnumerator(Vector v) {
     * 	vector = v;
     * 	count = 0;
     *    }
     *    public boolean hasMoreElements() {
     * 	//...
     *    }
     *    public Object nextElement() {
     * 	//...
     *    }
     * }
     * 
     * El objeto enum devuelto por la funcin miembro elements es de la clase VectorEnumerator,
     * sin embargo no podemos escribir
     * 
     *        VectorEnumerator enum=v.elements();
     * 
     * porque VectorEnumerator no es una clase pblica. 
     * Como podemos ver en su definicion, no tiene la palabra reservada public delante
     * de class. Sin embargo, podemos guardar un objeto de la clase VectorEnumerator en 
     * una variable enum del tipo Enumeration, por que la clase implementa dicho interface.
     * 
     *        <CODE>Enumeration enum=v.elements();
     *        while(enum.hasMoreElements()){
     *            System.out.print(enum.nextElement()+"\t");
     *        }</CODE>
     */
    
    public Enumeration keys() {
        return vectSortedHashtable.elements();
    }
    
    
   
    public void clear(){
        hashSortedHashtable = new Hashtable();
        vectSortedHashtable = new Vector();
    }
    
    
    /**
     * 
     * Este metodo almacena objetos (key) con una relacion a un valor double (value)
     * de manera ordenada de menor a mayor, y si es igual lo coloca antes del elemento al que es igual
     * 
     * <PRE>si llega un elemento (key) repetido se sobrescribe el mas nuevo con su nuevo valor</PRE>
     * @param key Objeto clave que se almacenara en el contenedor
     * @param value Valor de tipo double asociado al objeto clave
     */
    public void put(Object key, Double value){ 
        boolean bSorted = false;
    
       
        remove(key);
       
        for (int i = 0; i < vectSortedHashtable.size(); i++) {
            
            Double base = (Double) hashSortedHashtable.get(vectSortedHashtable.elementAt(i));
            
            if (base.compareTo(value) >= 0) { 
                vectSortedHashtable.insertElementAt(key, i);
                bSorted = true;
                break;
            }
        }
        
        if (!bSorted) {
            bSorted = true;
            vectSortedHashtable.addElement(key);
        }
        hashSortedHashtable.put(key, value);
        
    }
    
    public Double getValueOf(Object key){
        return (Double) hashSortedHashtable.get(key);
    }
    
    public int size(){
        
        return hashSortedHashtable.size();
    }
    
    public void remove(Object key){
        vectSortedHashtable.remove(key);
        hashSortedHashtable.remove(key);
    }
    
    public Object getKeyAt(int i){
        
        return vectSortedHashtable.elementAt(i);
        
    }
    public boolean containsKey(Object key){
        boolean b = false;
        try {
      
              
            b=   hashSortedHashtable.containsKey(key);
        } catch(NullPointerException ex) {
            System.out.println("key is null");
        }
        
            return b;
     
      
    }
   public boolean isEmpty(){
       
       if(hashSortedHashtable.isEmpty()==false){
           
            return false;
        }
        else{
            return true;
        }
   }

    public Integer givePositionLastCar() {
        if(vectSortedHashtable.size()!= 0){
            return (Integer)vectSortedHashtable.elementAt(0);
        }
        else{
            return new Integer(0);
        }
    }
    
    
    
    
    
} // end SortedHashtable




